home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / utils / file / managers / mc-3.2 / mc-3 / mc-3.2.1 / src / slint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-17  |  8.0 KB  |  403 lines
  1. /* Slang interface to the Midnight Commander
  2.    This emulates some features of ncurses on top of slang
  3.    Copyright (C) 1995 Miguel de Icaza
  4.    
  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 2 of the License, or
  8.    (at your option) any later version.
  9.    
  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.    GNU General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU General Public License
  16.    along with this program; if not, write to the Free Software
  17.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18. #include <config.h>
  19. #include <stdio.h>
  20. #include <unistd.h>
  21. #include <stdlib.h>
  22. #include <termios.h>
  23. #include <signal.h>
  24. #include "tty.h"
  25. #include "mad.h"
  26. #include "color.h"
  27. #include "util.h"
  28. #include "mouse.h"        /* Gpm_Event is required in key.h */
  29. #include "key.h"        /* define_sequence */
  30. #include "main.h"        /* extern: force_colors */
  31. #include "win.h"        /* do_exit_ca_mode */
  32.  
  33. #ifdef HAVE_SLANG
  34.  
  35. /* Taken from S-Lang's sldisply.c file */
  36. #ifndef USE_TERMCAP
  37. #   define tgetstr(a,b) SLtt_tgetstr (a)
  38. #else
  39.     extern char *tgetstr(char *, char **);
  40. #endif
  41.  
  42.  
  43. static struct termios boot_mode;
  44. static struct termios new_mode;
  45. static int Read_FD;
  46.  
  47. #if DEVELOPERS_ONLY
  48. static void slang_sigterm (int signo)
  49. {
  50.     SLsmg_reset_smg ();
  51.     kill (getpid (), signo);
  52. }
  53. #endif
  54.  
  55. static int slinterrupt;
  56.  
  57. static void slang_intr (int signo)
  58. {
  59.     slinterrupt = 1;
  60. }
  61.  
  62. void enable_interrupt_key(void)
  63. {
  64. #ifndef _OS_NT
  65.     struct sigaction act;
  66.     
  67. #ifdef SIGINT
  68.     act.sa_handler = slang_intr;
  69.     sigemptyset (&act.sa_mask);
  70.     act.sa_flags = 0;
  71.     sigaction (SIGINT, &act, NULL);
  72. #endif
  73. #endif
  74.     slinterrupt = 0;
  75. }
  76.  
  77. void disable_interrupt_key(void)
  78. {
  79. #ifndef _OS_NT
  80.     struct sigaction act;
  81.     
  82. #ifdef SIGINT
  83.     act.sa_handler = SIG_IGN;
  84.     act.sa_flags = 0;
  85.     sigemptyset (&act.sa_mask);
  86.     sigaction (SIGINT, &act, NULL);
  87. #endif
  88. #endif
  89. }
  90.  
  91. int got_interrupt ()
  92. {
  93.     int t;
  94.  
  95.     t = slinterrupt;
  96.     slinterrupt = 0;
  97.     return t;
  98. }
  99.  
  100. #ifdef _OS_NT
  101. #define tcgetattr(a,b)
  102. #endif
  103.  
  104. /* Only done the first time */
  105. void slang_init (void)
  106. {
  107. #ifndef _OS_NT
  108.     struct sigaction act, oact;
  109. #endif
  110.     
  111.     Read_FD = fileno (stdin);
  112.     SLtt_get_terminfo ();
  113.     tcgetattr (Read_FD, &boot_mode);
  114.     /* 255 = ignore abort char; XCTRL('g') for abort char = ^g */
  115.     SLang_init_tty (XCTRL('c'), 1, 0);    
  116.     tcgetattr (Read_FD, &new_mode);
  117.     slang_prog_mode ();
  118.     load_terminfo_keys ();
  119. #ifdef SIGINT
  120.     act.sa_handler = slang_intr;
  121.     sigemptyset (&act.sa_mask);
  122. #ifdef SA_RESTART
  123.     act.sa_flags = SA_RESTART;
  124. #endif
  125.     sigaction (SIGINT, &act, &oact);
  126. #endif
  127.  
  128. #if DEVELOPERS_ONLY
  129. #ifdef SIGHUP
  130.     signal (SIGHUP, slang_sigterm);
  131. #endif    
  132. #ifdef SIGQUIT
  133.     signal (SIGQUIT, slang_sigterm);
  134. #endif    
  135. #ifdef SIGABRT    
  136.     signal (SIGABRT, slang_sigterm);
  137. #endif    
  138. #ifdef SIGBUS    
  139.     signal (SIGBUS, slang_sigterm);
  140. #endif    
  141. #ifdef SIGSEGV    
  142.     signal (SIGSEGV, slang_sigterm);
  143. #endif    
  144. #ifdef SIGTERM    
  145.     signal (SIGTERM, slang_sigterm);
  146. #endif
  147. #endif
  148. }
  149.  
  150. /* Done each time we come back from done mode */
  151. void slang_prog_mode (void)
  152. {
  153.     tcsetattr (Read_FD, TCSANOW, &new_mode);
  154.     SLsmg_init_smg ();
  155.     SLsmg_touch_lines (0, LINES);
  156. }
  157.  
  158. /* Called each time we want to shutdown slang screen manager */
  159. void slang_shell_mode (void)
  160. {
  161.     tcsetattr (Read_FD, TCSANOW, &boot_mode);
  162. }
  163.  
  164. void slang_shutdown ()
  165. {
  166.     char *op_cap;
  167.     
  168.     slang_shell_mode ();
  169.     do_exit_ca_mode ();
  170.     SLang_reset_tty ();
  171.  
  172.     /* Load the op capability to reset the colors to those that were
  173.      * active when the program was started up
  174.      */
  175.     op_cap = SLtt_tgetstr ("op");
  176.     if (op_cap){
  177.     fprintf (stderr, "%s", op_cap);
  178.     fflush (stderr);
  179.     }
  180. }
  181.  
  182. /* keypad routines */
  183. void slang_keypad (int set)
  184. {
  185.     char *keypad_string;
  186.     
  187.     keypad_string = (char *) SLtt_tgetstr (set ? "ks" : "ke");
  188.     if (keypad_string)
  189.     SLtt_write_string (keypad_string);
  190. }
  191.  
  192. static int no_slang_delay;
  193.  
  194. void set_slang_delay (int v)
  195. {
  196.     no_slang_delay = v;
  197. }
  198.  
  199. void hline (int ch, int len)
  200. {
  201.     int last_x, last_y;
  202.  
  203.     last_x = SLsmg_get_column ();
  204.     last_y = SLsmg_get_row ();
  205.     
  206.     if (ch == 0)
  207.     ch = ACS_HLINE;
  208.  
  209.     if (ch == ACS_HLINE){
  210.     SLsmg_draw_hline (len);
  211.     } else {
  212.     while (len--)
  213.         addch (ch);
  214.     }
  215.     move (last_y, last_x);
  216. }
  217.  
  218. void vline (int character, int len)
  219. {
  220.     if (!slow_terminal){
  221.     SLsmg_draw_vline (len);
  222.     } else {
  223.     int last_x, last_y, pos = 0;
  224.  
  225.     last_x = SLsmg_get_column ();
  226.     last_y = SLsmg_get_row ();
  227.  
  228.     while (len--){
  229.         move (last_y + pos++, last_x);
  230.         addch (' ');
  231.     }
  232.     move (last_x, last_y);
  233.     }
  234. }
  235.  
  236. void init_pair (int index, char *foreground, char *background)
  237. {
  238.     SLtt_set_color (index, "", foreground, background);
  239. }
  240.  
  241. char *color_terminals [] = {
  242. #ifdef linux
  243.     "console",
  244. #endif
  245.     "linux",
  246.     "xterm-color",
  247.     "color-xterm",
  248.     "xtermc",
  249.     "ansi",
  250.     0
  251. };
  252.  
  253. int has_colors ()
  254. {
  255.     char *terminal = getenv ("TERM");
  256.     int  i;
  257.  
  258.     SLtt_Use_Ansi_Colors = force_colors;
  259.     if (NULL != getenv ("COLORTERM"))
  260.     SLtt_Use_Ansi_Colors = 1;
  261.  
  262.     /* We want to allow overwriding */
  263.     if (!disable_colors){
  264.     for (i = 0; color_terminals [i]; i++)
  265.         if (strcmp (color_terminals [i], terminal) == 0)
  266.         SLtt_Use_Ansi_Colors = 1;
  267.     }
  268.     
  269.     /* Setup emulated colors */
  270.     if (SLtt_Use_Ansi_Colors){
  271.     init_pair (A_REVERSE, "black", "white");
  272.     } else {
  273.     SLtt_set_mono (A_BOLD,    NULL, SLTT_BOLD_MASK);
  274.     SLtt_set_mono (A_REVERSE, NULL, SLTT_REV_MASK);
  275.     SLtt_set_mono (A_BOLD|A_REVERSE, NULL, SLTT_BOLD_MASK | SLTT_REV_MASK);
  276.     }
  277.     return SLtt_Use_Ansi_Colors;
  278. }
  279.  
  280. void attrset (int color)
  281. {
  282.     if (!SLtt_Use_Ansi_Colors){
  283.     SLsmg_set_color (color);
  284.     return;
  285.     }
  286.     
  287.     if (color & A_BOLD){
  288.     if (color == A_BOLD)
  289.         SLsmg_set_color (A_BOLD);
  290.     else
  291.         SLsmg_set_color ((color & (~A_BOLD)) + 8);
  292.     return;
  293.     }
  294.  
  295.     if (color == A_REVERSE)
  296.     SLsmg_set_color (A_REVERSE);
  297.     else
  298.     SLsmg_set_color (color);
  299. }
  300.  
  301. /* This table describes which capabilities we want and which values we
  302.  * assign to them.
  303.  */
  304. struct {
  305.     int  key_code;
  306.     char *key_name;
  307. } key_table [] = {
  308.     { KEY_F(0),  "k0" },
  309.     { KEY_F(1),  "k1" },
  310.     { KEY_F(2),  "k2" },
  311.     { KEY_F(3),  "k3" },
  312.     { KEY_F(4),  "k4" },
  313.     { KEY_F(5),  "k5" },
  314.     { KEY_F(6),  "k6" },
  315.     { KEY_F(7),  "k7" },
  316.     { KEY_F(8),  "k8" },
  317.     { KEY_F(9),  "k9" },
  318.     { KEY_F(10), "k;" },
  319.     { KEY_F(11), "F1" },
  320.     { KEY_F(12), "F2" },
  321.     { KEY_F(13), "F3" },
  322.     { KEY_F(14), "F4" },
  323.     { KEY_F(15), "F5" },
  324.     { KEY_F(16), "F6" },
  325.     { KEY_F(17), "F7" },
  326.     { KEY_F(18), "F8" },
  327.     { KEY_F(19), "F9" },
  328.     { KEY_F(20), "FA" },    
  329.     { KEY_IC,    "kI" },
  330.     { KEY_NPAGE, "kN" },
  331.     { KEY_PPAGE, "kP" },
  332.     { KEY_LEFT,  "kl" },
  333.     { KEY_RIGHT, "kr" },
  334.     { KEY_UP,    "ku" },
  335.     { KEY_DOWN,  "kd" },
  336.     { KEY_DC,    "kD" },
  337.     { KEY_BACKSPACE, "kb" },
  338.     { KEY_HOME,  "kh" },
  339.     { KEY_END,     "@7" },
  340.     { 0, 0}
  341. };
  342.     
  343. void do_define_key (int code, char *strcap)
  344. {
  345.     char    *seq;
  346.  
  347.     seq = (char *) SLtt_tgetstr (strcap);
  348.     if (seq)
  349.     define_sequence (code, seq, MCKEY_NOACTION);
  350. }
  351.  
  352. void load_terminfo_keys ()
  353. {
  354.     int i;
  355.  
  356.     for (i = 0; key_table [i].key_code; i++)
  357.     do_define_key (key_table [i].key_code, key_table [i].key_name);
  358. }
  359.  
  360. int getch ()
  361. {
  362.     unsigned int ch;
  363.  
  364.     if (no_slang_delay)
  365.     if (SLang_input_pending (0) == 0)
  366.         return -1;
  367.  
  368.     ch = SLang_getkey ();
  369.  
  370. #ifndef __GO32__
  371. #define DEC_8BIT_HACK 64
  372.  
  373.    /* This has the effect of mapping all characters in the range 128-159 to
  374.     * ESC [ something 
  375.     */
  376.    if ( (use_8th_bit_as_meta == 1) && (ch & 0x80) )
  377.      {
  378.     unsigned char i;
  379.     i = (unsigned char) (ch & 0x7F);
  380.     if (i < ' ')
  381.       {
  382.          i += DEC_8BIT_HACK;
  383.          SLang_ungetkey (i);
  384.          ch = 27;
  385.       }
  386.      }
  387.  
  388. #endif    
  389.  
  390.    return (ch);
  391. }
  392.  
  393. extern int slow_terminal;
  394.  
  395. #else
  396.  
  397. /* Non slang builds do not understand got_interrupt */
  398. int got_interrupt ()
  399. {
  400.     return 0;
  401. }
  402. #endif /* HAVE_SLANG */
  403.